Seeing is believing

Using FlashTorch 🔦 to shine a light on what neural nets "see"

by Misa Ogura

Hello, I'm Misa 👋

  • Originally from Tokyo, now based in London
  • Cancer Cell Biologist, turned Software Engineer
  • Currently at BBC R&D
  • Co-founder of Women Driven Development
  • Women in Data Science London Ambassador

Convolutional Neural Network (CNN)

Typical CNN Architecture

Image Convolution

CNN Visualisation Techniques

Saliency map

Activation maximisation

Demo 1

Introducing FlashTorch & how to visualise saliency maps

First things first - config & imports

$ pip install flashtorch
In [2]:
%matplotlib inline
%config InlineBackend.figure_format = 'retina'

import matplotlib.pyplot as plt

import torch
import torch.nn as nn
import torchvision.models as models

Load an image

In [3]:
from flashtorch.utils import load_image

image = load_image('../examples/images/great_grey_owl_01.jpg')

plt.imshow(image)
plt.title('Original image')
plt.axis('off');

Convert the PIL image to a torch tensor

In [4]:
from flashtorch.utils import apply_transforms

input_ = apply_transforms(image)

print(f'Before: {type(image)}')
print(f'After: {type(input_)}, {input_.shape}')

Before: <class 'PIL.Image.Image'>
After: <class 'torch.Tensor'>, torch.Size([1, 3, 224, 224])

Let's visualise the input first...

In [5]:
# plt.imshow(input_)
# plt.title('Input tensor')
# plt.axis('off');

RuntimeError: Can't call numpy() on Variable that requires grad. Use var.detach().numpy() instead.

Let's visualise the input (take two)

In [6]:
from flashtorch.utils import format_for_plotting

plt.imshow(format_for_plotting(input_))
plt.title('Input tensor')
plt.axis('off');

Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).

Let's visualise the input (take THREE)

In [7]:
from flashtorch.utils import denormalize

plt.imshow(format_for_plotting(denormalize(input_)))
plt.title('Input tensor')
plt.axis('off');

Load a pre-trained model & create a backprop object

In [8]:
from flashtorch.saliency import Backprop

model = models.alexnet(pretrained=True)

backprop = Backprop(model)

Signature:

    backprop.calculate_gradients(input_, target_class=None, take_max=False)

Retrieve the class index for the object in the input

In [9]:
from flashtorch.utils import ImageNetIndex 

imagenet = ImageNetIndex()
target_class = imagenet['great grey owl']

print(target_class)

24

It kind of does fuzzy-matching as well (to some extent...)

In [10]:
# imagenet['dog']

ValueError: Multiple potential matches found: maltese dog, old english sheepdog, shetland sheepdog, greater swiss mountain dog, bernese mountain dog, french bulldog, eskimo dog, african hunting dog, dogsled, hotdog

Finally! It's time to calculate the gradients of each pixel w.r.t. the input image

In [11]:
gradients = backprop.calculate_gradients(input_, target_class)

print(type(gradients), gradients.shape)

<class 'torch.Tensor'> torch.Size([3, 224, 224])

You can also take the maximum of the gradients across colour channels

In [12]:
max_gradients = backprop.calculate_gradients(input_, target_class, take_max=True)

print(type(max_gradients), max_gradients.shape)

<class 'torch.Tensor'> torch.Size([1, 224, 224])

Let's inspect gradients by plotting them out

In [13]:
from flashtorch.utils import visualize

visualize(input_, gradients, max_gradients)

It kind of shows that pixels around the area where the animal is present had strongest positive effects on the prediction.

But it's quite noisy...

Guided backprop to the rescue!

In [14]:
guided_gradients = backprop.calculate_gradients(input_, target_class, guided=True)
max_guided_gradients = backprop.calculate_gradients(input_, target_class, take_max=True, guided=True)
In [15]:
visualize(input_, guided_gradients, max_guided_gradients)

Now that's much less noisy!

We can clearly see that pixels around the head and eyes had strongest positive effects on the prediction.

What about a jay?

In [17]:
visualize(input_, guided_gradients, max_guided_gradients)

Or an oystercatcher...

In [19]:
visualize(input_, guided_gradients, max_guided_gradients)

Demo 2

Using FlashTorch to gain additional insights on transfer learning

In [21]:
image = load_image('../examples/images/foxglove.jpg')
input_ = apply_transforms(image)

class_index = 96  # foxglove

pretrained_model = create_model()

backprop = Backprop(pretrained_model)

guided_gradients = backprop.calculate_gradients(input_, class_index, guided=True)
guided_max_gradients = backprop.calculate_gradients(input_, class_index, take_max=True, guided=True)

visualize(input_, guided_gradients, guided_max_gradients)

/Users/misao/Projects/personal/flashtorch/flashtorch/saliency/backprop.py:93: UserWarning: The predicted class does not equal the
                target class. Calculating the gradient with respect to the
                predicted class.
  predicted class.'''))
In [22]:
trained_model = create_model('../models/flower_classification_transfer_learning.pt')

backprop = Backprop(trained_model)

guided_gradients = backprop.calculate_gradients(input_, class_index, guided=True)
guided_max_gradients = backprop.calculate_gradients(input_, class_index, take_max=True, guided=True)

visualize(input_, guided_gradients, guided_max_gradients)